{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1c312e2f-2985-4043-9115-2af39967f440",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "已强制使用设备: cpu\n",
      "数据集信息：训练集16200，验证集1800，批次大小16\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader, random_split\n",
    "from torchmetrics import Accuracy\n",
    "import numpy as np\n",
    "from pathlib import Path\n",
    "import os\n",
    "import time\n",
    "\n",
    "# 强制使用CPU确保稳定性\n",
    "device = 'cpu'\n",
    "print(f\"已强制使用设备: {device}\")\n",
    "\n",
    "# 设置随机种子\n",
    "torch.manual_seed(42)\n",
    "\n",
    "# 1. 数据准备\n",
    "# 加载原始数据集用于计算均值和标准差\n",
    "raw_train_dataset = datasets.MNIST(root=\"./datasets/\", train=True, download=True, transform=None)\n",
    "\n",
    "# 计算均值和标准差（使用前1000个样本）\n",
    "imgs = torch.stack([transforms.ToTensor()(raw_train_dataset[i][0]) for i in range(1000)], dim=0)\n",
    "mean = imgs.view(1, -1).mean(dim=1)\n",
    "std = imgs.view(1, -1).std(dim=1)\n",
    "\n",
    "# 定义数据变换\n",
    "mnist_transforms = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(mean=mean, std=std)\n",
    "])\n",
    "\n",
    "# 应用变换加载数据集\n",
    "train_val_dataset = datasets.MNIST(root=\"./datasets/\", train=True, download=False, transform=mnist_transforms)\n",
    "test_dataset = datasets.MNIST(root=\"./datasets/\", train=False, download=False, transform=mnist_transforms)\n",
    "\n",
    "# 减小数据集规模\n",
    "small_train_size = int(0.3 * len(train_val_dataset))\n",
    "train_val_dataset, _ = random_split(train_val_dataset, [small_train_size, len(train_val_dataset)-small_train_size])\n",
    "\n",
    "# 分割训练集和验证集\n",
    "train_size = int(0.9 * len(train_val_dataset))\n",
    "val_size = len(train_val_dataset) - train_size\n",
    "train_dataset, val_dataset = random_split(train_val_dataset, [train_size, val_size])\n",
    "\n",
    "# 批次大小\n",
    "BATCH_SIZE = 16\n",
    "train_dataloader = DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "val_dataloader = DataLoader(dataset=val_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "test_dataloader = DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "\n",
    "print(f\"数据集信息：训练集{len(train_dataset)}，验证集{len(val_dataset)}，批次大小{BATCH_SIZE}\")\n",
    "\n",
    "# 2. 定义LeNet5模型\n",
    "class LeNet5(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.feature = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, stride=1, padding=2),\n",
    "            nn.Tanh(),\n",
    "            nn.AvgPool2d(kernel_size=2, stride=2),\n",
    "            nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5, stride=1),\n",
    "            nn.Tanh(),\n",
    "            nn.AvgPool2d(kernel_size=2, stride=2),\n",
    "        )\n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(in_features=16*5*5, out_features=120),\n",
    "            nn.Tanh(),\n",
    "            nn.Linear(in_features=120, out_features=84),\n",
    "            nn.Tanh(),\n",
    "            nn.Linear(in_features=84, out_features=10),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.classifier(self.feature(x))\n",
    "\n",
    "# 3. 训练函数（减少批次输出）\n",
    "def train_model(model, train_dataloader, val_dataloader, loss_fn, optimizer, accuracy, \n",
    "                device, epochs=2, model_name=\"lenet5\"):\n",
    "    start_time = time.time()\n",
    "    results = {\"train_loss\": [], \"train_acc\": [], \"val_loss\": [], \"val_acc\": []}\n",
    "    model.to(device)\n",
    "    accuracy.to(device)\n",
    "    \n",
    "    print(f\"开始训练{model_name}，共{epochs}轮，设备{device}\")\n",
    "    for epoch in range(epochs):\n",
    "        print(f\"\\n===== Epoch {epoch+1}/{epochs} =====\")\n",
    "        train_loss, train_acc = 0.0, 0.0\n",
    "        model.train()\n",
    "        \n",
    "        for batch, (X, y) in enumerate(train_dataloader):\n",
    "            # 每50个批次打印一次，减少输出\n",
    "            if batch % 200 == 0 and batch > 0:\n",
    "                print(f\"  已处理 {batch}/{len(train_dataloader)} 批次\")\n",
    "            \n",
    "            X, y = X.to(device), y.to(device)\n",
    "            y_pred = model(X)\n",
    "            loss = loss_fn(y_pred, y)\n",
    "            train_loss += loss.item()\n",
    "            acc = accuracy(y_pred, y)\n",
    "            train_acc += acc\n",
    "            \n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "        \n",
    "        train_loss /= len(train_dataloader)\n",
    "        train_acc /= len(train_dataloader)\n",
    "        print(f\"训练损失: {train_loss:.5f} | 训练准确率: {train_acc:.5f}\")\n",
    "        \n",
    "        val_loss, val_acc = 0.0, 0.0\n",
    "        model.eval()\n",
    "        with torch.inference_mode():\n",
    "            for X, y in val_dataloader:\n",
    "                X, y = X.to(device), y.to(device)\n",
    "                y_pred = model(X)\n",
    "                val_loss += loss_fn(y_pred, y).item()\n",
    "                val_acc += accuracy(y_pred, y)\n",
    "            \n",
    "            val_loss /= len(val_dataloader)\n",
    "            val_acc /= len(val_dataloader)\n",
    "            print(f\"验证损失: {val_loss:.5f} | 验证准确率: {val_acc:.5f}\")\n",
    "        \n",
    "        results[\"train_loss\"].append(train_loss)\n",
    "        results[\"train_acc\"].append(train_acc.cpu().item())\n",
    "        results[\"val_loss\"].append(val_loss)\n",
    "        results[\"val_acc\"].append(val_acc.cpu().item())\n",
    "    \n",
    "    training_time = time.time() - start_time\n",
    "    print(f\"{model_name} 训练完成，耗时: {training_time:.2f}秒\")\n",
    "    return model, results, training_time\n",
    "\n",
    "# 4. 测试函数\n",
    "def test_model(model, test_dataloader, loss_fn, accuracy, device):\n",
    "    test_loss, test_acc = 0.0, 0.0\n",
    "    model.to(device)\n",
    "    model.eval()\n",
    "    with torch.inference_mode():\n",
    "        for X, y in test_dataloader:\n",
    "            X, y = X.to(device), y.to(device)\n",
    "            y_pred = model(X)\n",
    "            test_loss += loss_fn(y_pred, y).item()\n",
    "            test_acc += accuracy(y_pred, y).item()\n",
    "        \n",
    "        test_loss /= len(test_dataloader)\n",
    "        test_acc /= len(test_dataloader)\n",
    "    \n",
    "    print(f\"测试损失: {test_loss:.5f} | 测试准确率: {test_acc:.5f}\")\n",
    "    return test_loss, test_acc\n",
    "\n",
    "# 初始化结果存储变量\n",
    "all_results = {}\n",
    "training_times = {}\n",
    "test_metrics = {}\n",
    "\n",
    "# 公共参数\n",
    "EPOCHS = 4\n",
    "loss_fn = nn.CrossEntropyLoss()\n",
    "accuracy = Accuracy(task='multiclass', num_classes=10)\n",
    "\n",
    "# 创建模型保存目录\n",
    "MODEL_PATH = Path(\"models\")\n",
    "MODEL_PATH.mkdir(parents=True, exist_ok=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "add8d716-75fd-449e-b49e-d4bf4d6bc410",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "===== 开始使用 SGD (Momentum=0.9) 优化器训练 =====\n",
      "开始训练SGD (Momentum=0.9)，共4轮，设备cpu\n",
      "\n",
      "===== Epoch 1/4 =====\n",
      "  已处理 200/1013 批次\n",
      "  已处理 400/1013 批次\n",
      "  已处理 600/1013 批次\n",
      "  已处理 800/1013 批次\n",
      "  已处理 1000/1013 批次\n",
      "训练损失: 0.43120 | 训练准确率: 0.86735\n",
      "验证损失: 0.15367 | 验证准确率: 0.95796\n",
      "\n",
      "===== Epoch 2/4 =====\n",
      "  已处理 200/1013 批次\n",
      "  已处理 400/1013 批次\n",
      "  已处理 600/1013 批次\n",
      "  已处理 800/1013 批次\n",
      "  已处理 1000/1013 批次\n",
      "训练损失: 0.11987 | 训练准确率: 0.96310\n",
      "验证损失: 0.12201 | 验证准确率: 0.96128\n",
      "\n",
      "===== Epoch 3/4 =====\n",
      "  已处理 200/1013 批次\n",
      "  已处理 400/1013 批次\n",
      "  已处理 600/1013 批次\n",
      "  已处理 800/1013 批次\n",
      "  已处理 1000/1013 批次\n",
      "训练损失: 0.07737 | 训练准确率: 0.97544\n",
      "验证损失: 0.10191 | 验证准确率: 0.96847\n",
      "\n",
      "===== Epoch 4/4 =====\n",
      "  已处理 200/1013 批次\n",
      "  已处理 400/1013 批次\n",
      "  已处理 600/1013 批次\n",
      "  已处理 800/1013 批次\n",
      "  已处理 1000/1013 批次\n",
      "训练损失: 0.05955 | 训练准确率: 0.98180\n",
      "验证损失: 0.09020 | 验证准确率: 0.97179\n",
      "SGD (Momentum=0.9) 训练完成，耗时: 19.79秒\n",
      "\n",
      "===== SGD (Momentum=0.9) 测试结果 =====\n",
      "测试损失: 0.06925 | 测试准确率: 0.97690\n",
      "模型已保存至: models/lenet5_sgd_momentum=0.9_mnist.pth\n"
     ]
    }
   ],
   "source": [
    "# 训练SGD (Momentum=0.9)\n",
    "optimizer_name = \"SGD (Momentum=0.9)\"\n",
    "print(f\"\\n===== 开始使用 {optimizer_name} 优化器训练 =====\")\n",
    "\n",
    "# 初始化模型和优化器\n",
    "model = LeNet5()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)\n",
    "\n",
    "# 训练模型\n",
    "trained_model, results, train_time = train_model(\n",
    "    model=model,\n",
    "    train_dataloader=train_dataloader,\n",
    "    val_dataloader=val_dataloader,\n",
    "    loss_fn=loss_fn,\n",
    "    optimizer=optimizer,\n",
    "    accuracy=accuracy,\n",
    "    device=device,\n",
    "    epochs=EPOCHS,\n",
    "    model_name=optimizer_name\n",
    ")\n",
    "\n",
    "# 测试模型\n",
    "print(f\"\\n===== {optimizer_name} 测试结果 =====\")\n",
    "test_loss, test_acc = test_model(trained_model, test_dataloader, loss_fn, accuracy, device)\n",
    "\n",
    "# 保存结果\n",
    "all_results[optimizer_name] = results\n",
    "training_times[optimizer_name] = train_time\n",
    "test_metrics[optimizer_name] = {\"loss\": test_loss, \"acc\": test_acc}\n",
    "\n",
    "# 保存模型\n",
    "MODEL_SAVE_PATH = MODEL_PATH / f\"lenet5_{optimizer_name.lower().replace(' ', '_').replace('(','').replace(')','')}_mnist.pth\"\n",
    "torch.save(obj=trained_model.state_dict(), f=MODEL_SAVE_PATH)\n",
    "print(f\"模型已保存至: {MODEL_SAVE_PATH}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "73800843-25d7-445a-8e7c-e1a37d4a8979",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "===== 开始使用 Adam 优化器训练 =====\n",
      "开始训练Adam，共4轮，设备cpu\n",
      "\n",
      "===== Epoch 1/4 =====\n",
      "  已处理 200/1013 批次\n",
      "  已处理 400/1013 批次\n",
      "  已处理 600/1013 批次\n",
      "  已处理 800/1013 批次\n",
      "  已处理 1000/1013 批次\n",
      "训练损失: 0.35612 | 训练准确率: 0.89326\n",
      "验证损失: 0.18597 | 验证准确率: 0.94358\n",
      "\n",
      "===== Epoch 2/4 =====\n",
      "  已处理 200/1013 批次\n",
      "  已处理 400/1013 批次\n",
      "  已处理 600/1013 批次\n",
      "  已处理 800/1013 批次\n",
      "  已处理 1000/1013 批次\n",
      "训练损失: 0.13814 | 训练准确率: 0.95700\n",
      "验证损失: 0.13000 | 验证准确率: 0.95962\n",
      "\n",
      "===== Epoch 3/4 =====\n",
      "  已处理 200/1013 批次\n",
      "  已处理 400/1013 批次\n",
      "  已处理 600/1013 批次\n",
      "  已处理 800/1013 批次\n",
      "  已处理 1000/1013 批次\n",
      "训练损失: 0.08548 | 训练准确率: 0.97396\n",
      "验证损失: 0.10139 | 验证准确率: 0.97179\n",
      "\n",
      "===== Epoch 4/4 =====\n",
      "  已处理 200/1013 批次\n",
      "  已处理 400/1013 批次\n",
      "  已处理 600/1013 批次\n",
      "  已处理 800/1013 批次\n",
      "  已处理 1000/1013 批次\n",
      "训练损失: 0.06374 | 训练准确率: 0.97927\n",
      "验证损失: 0.12902 | 验证准确率: 0.96128\n",
      "Adam 训练完成，耗时: 22.13秒\n",
      "\n",
      "===== Adam 测试结果 =====\n",
      "测试损失: 0.11900 | 测试准确率: 0.96290\n",
      "模型已保存至: models/lenet5_adam_mnist.pth\n"
     ]
    }
   ],
   "source": [
    "# 训练Adam\n",
    "optimizer_name = \"Adam\"\n",
    "print(f\"\\n===== 开始使用 {optimizer_name} 优化器训练 =====\")\n",
    "\n",
    "# 初始化模型和优化器\n",
    "model = LeNet5()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 训练模型\n",
    "trained_model, results, train_time = train_model(\n",
    "    model=model,\n",
    "    train_dataloader=train_dataloader,\n",
    "    val_dataloader=val_dataloader,\n",
    "    loss_fn=loss_fn,\n",
    "    optimizer=optimizer,\n",
    "    accuracy=accuracy,\n",
    "    device=device,\n",
    "    epochs=EPOCHS,\n",
    "    model_name=optimizer_name\n",
    ")\n",
    "\n",
    "# 测试模型\n",
    "print(f\"\\n===== {optimizer_name} 测试结果 =====\")\n",
    "test_loss, test_acc = test_model(trained_model, test_dataloader, loss_fn, accuracy, device)\n",
    "\n",
    "# 保存结果\n",
    "all_results[optimizer_name] = results\n",
    "training_times[optimizer_name] = train_time\n",
    "test_metrics[optimizer_name] = {\"loss\": test_loss, \"acc\": test_acc}\n",
    "\n",
    "# 保存模型\n",
    "MODEL_SAVE_PATH = MODEL_PATH / f\"lenet5_{optimizer_name.lower()}_mnist.pth\"\n",
    "torch.save(obj=trained_model.state_dict(), f=MODEL_SAVE_PATH)\n",
    "print(f\"模型已保存至: {MODEL_SAVE_PATH}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f0cfabe4-d4dd-4c7c-aac1-53d4ad78bc0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "===== 开始使用 RMSprop 优化器训练 =====\n",
      "开始训练RMSprop，共4轮，设备cpu\n",
      "\n",
      "===== Epoch 1/4 =====\n",
      "  已处理 200/1013 批次\n",
      "  已处理 400/1013 批次\n",
      "  已处理 600/1013 批次\n",
      "  已处理 800/1013 批次\n",
      "  已处理 1000/1013 批次\n",
      "训练损失: 0.28734 | 训练准确率: 0.91276\n",
      "验证损失: 0.16365 | 验证准确率: 0.95243\n",
      "\n",
      "===== Epoch 2/4 =====\n",
      "  已处理 200/1013 批次\n",
      "  已处理 400/1013 批次\n",
      "  已处理 600/1013 批次\n",
      "  已处理 800/1013 批次\n",
      "  已处理 1000/1013 批次\n",
      "训练损失: 0.11223 | 训练准确率: 0.96446\n",
      "验证损失: 0.17201 | 验证准确率: 0.94469\n",
      "\n",
      "===== Epoch 3/4 =====\n",
      "  已处理 200/1013 批次\n",
      "  已处理 400/1013 批次\n",
      "  已处理 600/1013 批次\n",
      "  已处理 800/1013 批次\n",
      "  已处理 1000/1013 批次\n",
      "训练损失: 0.07399 | 训练准确率: 0.97754\n",
      "验证损失: 0.11330 | 验证准确率: 0.96405\n",
      "\n",
      "===== Epoch 4/4 =====\n",
      "  已处理 200/1013 批次\n",
      "  已处理 400/1013 批次\n",
      "  已处理 600/1013 批次\n",
      "  已处理 800/1013 批次\n",
      "  已处理 1000/1013 批次\n",
      "训练损失: 0.05597 | 训练准确率: 0.98266\n",
      "验证损失: 0.07796 | 验证准确率: 0.97732\n",
      "RMSprop 训练完成，耗时: 20.74秒\n",
      "\n",
      "===== RMSprop 测试结果 =====\n",
      "测试损失: 0.06114 | 测试准确率: 0.98040\n",
      "模型已保存至: models/lenet5_rmsprop_mnist.pth\n"
     ]
    }
   ],
   "source": [
    "# 训练RMSprop\n",
    "optimizer_name = \"RMSprop\"\n",
    "print(f\"\\n===== 开始使用 {optimizer_name} 优化器训练 =====\")\n",
    "\n",
    "# 初始化模型和优化器\n",
    "model = LeNet5()\n",
    "optimizer = torch.optim.RMSprop(model.parameters(), lr=0.001)\n",
    "\n",
    "# 训练模型\n",
    "trained_model, results, train_time = train_model(\n",
    "    model=model,\n",
    "    train_dataloader=train_dataloader,\n",
    "    val_dataloader=val_dataloader,\n",
    "    loss_fn=loss_fn,\n",
    "    optimizer=optimizer,\n",
    "    accuracy=accuracy,\n",
    "    device=device,\n",
    "    epochs=EPOCHS,\n",
    "    model_name=optimizer_name\n",
    ")\n",
    "\n",
    "# 测试模型\n",
    "print(f\"\\n===== {optimizer_name} 测试结果 =====\")\n",
    "test_loss, test_acc = test_model(trained_model, test_dataloader, loss_fn, accuracy, device)\n",
    "\n",
    "# 保存结果\n",
    "all_results[optimizer_name] = results\n",
    "training_times[optimizer_name] = train_time\n",
    "test_metrics[optimizer_name] = {\"loss\": test_loss, \"acc\": test_acc}\n",
    "\n",
    "# 保存模型\n",
    "MODEL_SAVE_PATH = MODEL_PATH / f\"lenet5_{optimizer_name.lower()}_mnist.pth\"\n",
    "torch.save(obj=trained_model.state_dict(), f=MODEL_SAVE_PATH)\n",
    "print(f\"模型已保存至: {MODEL_SAVE_PATH}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c2e4e252-3b1a-43fa-b0db-0a773edf14f5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "===== Experiment Summary =====\n",
      "\n",
      "Training Time Comparison:\n",
      "SGD (Momentum=0.9): 19.79 seconds\n",
      "Adam: 22.13 seconds\n",
      "RMSprop: 20.74 seconds\n",
      "\n",
      "Test Accuracy Comparison:\n",
      "SGD (Momentum=0.9): 0.9769\n",
      "Adam: 0.9629\n",
      "RMSprop: 0.9804\n",
      "\n",
      "Maximum Validation Accuracy Comparison:\n",
      "SGD (Momentum=0.9): 0.9718\n",
      "Adam: 0.9718\n",
      "RMSprop: 0.9773\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题\n",
    "\n",
    "# 结果可视化函数\n",
    "def plot_results(results_dict, metrics=[\"loss\", \"acc\"]):\n",
    "    plt.style.use('seaborn-v0_8')\n",
    "    \n",
    "    for metric in metrics:\n",
    "        plt.figure(figsize=(10, 6))\n",
    "        handles, labels = [], []\n",
    "        \n",
    "        for optimizer_name, results in results_dict.items():\n",
    "            if metric == \"loss\":\n",
    "                # 训练损失曲线\n",
    "                train_line, = plt.plot(results[\"train_loss\"], label=f\"{optimizer_name} - Train Loss\")\n",
    "                # 验证损失曲线\n",
    "                val_line, = plt.plot(results[\"val_loss\"], label=f\"{optimizer_name} - Validation Loss\", linestyle='--')\n",
    "                \n",
    "                handles.extend([train_line, val_line])\n",
    "                labels.extend([f\"{optimizer_name} - Train Loss\", f\"{optimizer_name} - Validation Loss\"])\n",
    "                \n",
    "                plt.ylabel(\"Loss Value\")\n",
    "                plt.title(\"Loss Curves of Different Optimizers\")\n",
    "            else:  # accuracy\n",
    "                # 训练准确率曲线\n",
    "                train_line, = plt.plot(results[\"train_acc\"], label=f\"{optimizer_name} - Train Accuracy\")\n",
    "                # 验证准确率曲线\n",
    "                val_line, = plt.plot(results[\"val_acc\"], label=f\"{optimizer_name} - Validation Accuracy\", linestyle='--')\n",
    "                \n",
    "                handles.extend([train_line, val_line])\n",
    "                labels.extend([f\"{optimizer_name} - Train Accuracy\", f\"{optimizer_name} - Validation Accuracy\"])\n",
    "                \n",
    "                plt.ylabel(\"Accuracy\")\n",
    "                plt.title(\"Accuracy Curves of Different Optimizers\")\n",
    "        \n",
    "        plt.xlabel(\"Epoch\")\n",
    "        plt.legend(handles, labels, loc='best')\n",
    "        plt.grid(True, alpha=0.3)\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "# 生成结果对比图（检查数据是否存在）\n",
    "if 'all_results' in locals() and len(all_results) > 0:\n",
    "    plot_results(all_results, metrics=[\"loss\", \"acc\"])\n",
    "    \n",
    "    # 打印实验总结\n",
    "    print(\"\\n===== Experiment Summary =====\")\n",
    "    \n",
    "    # 训练时间对比\n",
    "    print(\"\\nTraining Time Comparison:\")\n",
    "    for name, time in training_times.items():\n",
    "        print(f\"{name}: {time:.2f} seconds\")\n",
    "    \n",
    "    # 测试准确率对比\n",
    "    print(\"\\nTest Accuracy Comparison:\")\n",
    "    for name, metrics in test_metrics.items():\n",
    "        print(f\"{name}: {metrics['acc']:.4f}\")\n",
    "    \n",
    "    # 最高验证准确率对比\n",
    "    print(\"\\nMaximum Validation Accuracy Comparison:\")\n",
    "    for name, results in all_results.items():\n",
    "        max_acc = max(results[\"val_acc\"])\n",
    "        print(f\"{name}: {max_acc:.4f}\")\n",
    "else:\n",
    "    print(\"No training results found. Please complete training for all optimizers first.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7602c90-272a-4d54-a601-ba9554c484e2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
